#if 0
#include "cvariant.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

// 操作类型枚举
typedef enum {
    OP_ADD,       // 整数/浮点数加法
    OP_SUB,       // 整数/浮点数减法
    OP_MUL,       // 浮点数乘法
    OP_DIV,       // 浮点数除法
    OP_UPPER,     // 字符串转大写
    OP_LOWER,     // 字符串转小写
    OP_APPEND,    // 字符串拼接
    OP_UNKNOWN    // 未知操作
} OpType;

// 解析操作类型
static OpType parse_operation(const char* op) {
    if (strcmp(op, "add") == 0) return OP_ADD;
    if (strcmp(op, "sub") == 0) return OP_SUB;
    if (strcmp(op, "mul") == 0) return OP_MUL;
    if (strcmp(op, "div") == 0) return OP_DIV;
    if (strcmp(op, "upper") == 0) return OP_UPPER;
    if (strcmp(op, "lower") == 0) return OP_LOWER;
    if (strcmp(op, "append") == 0) return OP_APPEND;
    return OP_UNKNOWN;
}

// 识别输入数据类型并存储到variant
static void detect_type_and_set(CVariant* var, const char* input) {
    // 尝试识别为整数
    char* endptr;
    long int_val = strtol(input, &endptr, 10);
    if (*endptr == '\0') {
        cvariant_set_int(var, (int)int_val);
        return;
    }

    // 尝试识别为浮点数
    double float_val = strtod(input, &endptr);
    if (*endptr == '\0') {
        cvariant_set_double(var, float_val);
        return;
    }

    // 否则视为字符串
    cvariant_set_str(var, input);
}

// 执行整数操作
static void process_int(CVariant* var, OpType op, const char* arg) {
    int val = cvariant_get_int(var);
    int num = atoi(arg);  // 操作参数（整数）

    switch (op) {
        case OP_ADD:
            cvariant_set_int(var, val + num);
            break;
        case OP_SUB:
            cvariant_set_int(var, val - num);
            break;
        default:
            fprintf(stderr, "错误：整数不支持该操作\n");
    }
}

// 执行浮点数操作
static void process_double(CVariant* var, OpType op, const char* arg) {
    double val = cvariant_get_double(var);
    double num = atof(arg);  // 操作参数（浮点数）

    switch (op) {
        case OP_ADD:
            cvariant_set_double(var, val + num);
            break;
        case OP_SUB:
            cvariant_set_double(var, val - num);
            break;
        case OP_MUL:
            cvariant_set_double(var, val * num);
            break;
        case OP_DIV:
            if (num == 0) {
                fprintf(stderr, "错误：除数不能为0\n");
                return;
            }
            cvariant_set_double(var, val / num);
            break;
        default:
            fprintf(stderr, "错误：浮点数不支持该操作\n");
    }
}

// 执行字符串操作
static void process_str(CVariant* var, OpType op, const char* arg) {
    const char* val = cvariant_get_str(var);
    char* result = NULL;

    switch (op) {
        case OP_UPPER: {
            result = strdup(val);
            for (int i = 0; result[i]; i++)
                result[i] = toupper(result[i]);
            break;
        }
        case OP_LOWER: {
            result = strdup(val);
            for (int i = 0; result[i]; i++)
                result[i] = tolower(result[i]);
            break;
        }
        case OP_APPEND: {
            result = (char*)malloc(strlen(val) + strlen(arg) + 1);
            strcpy(result, val);
            strcat(result, arg);
            break;
        }
        default:
            fprintf(stderr, "错误：字符串不支持该操作\n");
            return;
    }

    cvariant_set_str(var, result);
    free(result);  // 字符串由variant引用，此处释放临时内存
}

// 显示使用帮助
static void print_help(const char* progname) {
    printf("用法：%s [操作] [参数] [输入数据]\n", progname);
    printf("支持的操作：\n");
    printf("  add <num>    对整数/浮点数执行加法\n");
    printf("  sub <num>    对整数/浮点数执行减法\n");
    printf("  mul <num>    对浮点数执行乘法\n");
    printf("  div <num>    对浮点数执行除法\n");
    printf("  upper        字符串转大写\n");
    printf("  lower        字符串转小写\n");
    printf("  append <str> 字符串拼接\n");
    printf("示例：\n");
    printf("  %s add 5 100      → 100 + 5 = 105\n", progname);
    printf("  %s mul 2.5 3.2    → 3.2 × 2.5 = 8.0\n", progname);
    printf("  %s upper hello    → HELLO\n", progname);
}

int main(int argc, char* argv[]) {
    // 检查命令行参数
    if (argc < 3) {
        print_help(argv[0]);
        return 1;
    }

    // 解析操作和参数
    OpType op = parse_operation(argv[1]);
    if (op == OP_UNKNOWN) {
        fprintf(stderr, "错误：未知操作 '%s'\n", argv[1]);
        return 1;
    }

    // 特殊处理无参数的操作（upper/lower）
    int arg_idx = 2;
    const char* op_arg = NULL;
    if (op != OP_UPPER && op != OP_LOWER) {
        if (argc < 4) {
            print_help(argv[0]);
            return 1;
        }
        op_arg = argv[2];
        arg_idx = 3;
    }

    // 创建variant并存储输入数据
    CVariant* var = cvariant_create();
    if (!var) {
        fprintf(stderr, "错误：创建数据容器失败\n");
        return 1;
    }
    detect_type_and_set(var, argv[arg_idx]);

    // 根据数据类型执行对应操作
    switch (cvariant_get_type(var)) {
        case TYPE_INT:
            process_int(var, op, op_arg);
            break;
        case TYPE_DOUBLE:
            process_double(var, op, op_arg);
            break;
        case TYPE_STR:
            process_str(var, op, op_arg);
            break;
        default:
            fprintf(stderr, "错误：不支持的数据类型\n");
            cvariant_destroy(var);
            return 1;
    }

    // 输出结果
    switch (cvariant_get_type(var)) {
        case TYPE_INT:
            printf("%d\n", cvariant_get_int(var));
            break;
        case TYPE_DOUBLE:
            printf("%g\n", cvariant_get_double(var));  // 自动省略多余小数位
            break;
        case TYPE_STR:
            printf("%s\n", cvariant_get_str(var));
            break;
    }

    // 清理资源
    cvariant_destroy(var);
    return 0;
}
#endif